package com.styletransfer.service;

import com.styletransfer.mapper.StyleMapper;
import com.styletransfer.mapper.StyleTaskMapper;
import com.styletransfer.model.ApiResponse;
import com.styletransfer.model.Style;
import com.styletransfer.model.StyleTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import java.util.stream.Collectors;

import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 风格转换任务服务类
 */
@Service
public class StyleTaskService {

    @Autowired
    private StyleTaskMapper styleTaskMapper;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private StyleService styleService;

    @Autowired
    private StyleMapper styleMapper;

    @Autowired
    private WorkService workService;

    @Autowired
    private OssService ossService;

    @Value("${coze.api.token}")
    private String cozeApiToken;

    @Value("${coze.api.base-url}")
    private String cozeApiBaseUrl;

    @Value("${coze.workflow.style-transfer-id}")
    private String styleTransferWorkflowId;

    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(StyleTaskService.class);

    /**
     * 创建风格转换任务
     *
     * @param imageUrl 原图URL
     * @param styleIds 风格ID列表
     * @param intensity 风格强度
     * @return 任务ID
     */
    public ApiResponse<Map<String, Object>> createTask(String imageUrl, List<Long> styleIds, Integer intensity) {
        // 参数校验
        if (imageUrl == null || imageUrl.isEmpty()) {
            return ApiResponse.error("图片URL不能为空");
        }

        if (styleIds == null || styleIds.isEmpty()) {
            return ApiResponse.error("至少需要选择一种风格");
        }

        if (intensity == null || intensity < 0 || intensity > 100) {
            intensity = 100; // 默认强度为100
        }

        try {
            // 获取当前用户ID
            Long userId = getCurrentUserId();

            // 创建任务对象
            StyleTask task = new StyleTask();
            task.setId(generateTaskId());
            task.setUserId(userId);
            task.setImageUrl(imageUrl);
            task.setStyleIds(convertStyleIdsToString(styleIds));
            task.setIntensity(intensity);
            task.setStatus("waiting"); // 初始状态为等待处理

            // 保存任务
            styleTaskMapper.insert(task);

            // 调用Coze工作流API进行风格转换
            callCozeWorkflowApi(task);

            // 返回任务ID
            Map<String, Object> result = new HashMap<>();
            result.put("taskId", task.getId());
            return ApiResponse.success(result);
        } catch (Exception e) {
            return ApiResponse.error("创建任务失败: " + e.getMessage());
        }
    }

    /**
     * 调用Coze工作流API进行风格转换
     *
     * @param task 风格转换任务
     */
    private void callCozeWorkflowApi(StyleTask task) {
        try {
            // 准备请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.set("Authorization", "Bearer " + cozeApiToken);

            // 准备请求体
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("workflow_id", styleTransferWorkflowId);

            // 工作流参数
            Map<String, Object> parameters = new HashMap<>();

            // 构建符合Coze API要求的参数格式
            // 获取所有风格名称并组合
            StringBuilder styleNameBuilder = new StringBuilder();
            String[] styleIds = task.getStyleIds().split(",");
            
            for (int i = 0; i < styleIds.length; i++) {
                String styleName = getStyleNameById(styleIds[i].trim());
                if (styleName != null && !styleName.isEmpty()) {
                    if (styleNameBuilder.length() > 0) {
                        styleNameBuilder.append(" ");
                    }
                    styleNameBuilder.append(styleName);
                }
            }
            
            // 如果没有有效的风格名称，使用默认风格
            String finalStyleName = styleNameBuilder.length() > 0 ? 
                styleNameBuilder.toString() : "日漫风格";

            // 构建图片URL数组
            List<String> urls = new ArrayList<>();
            urls.add(task.getImageUrl());

            // 添加参数
            parameters.put("prompt", finalStyleName);
            parameters.put("urls", urls);

            requestBody.put("parameters", parameters);
            // 设置为异步执行
            requestBody.put("is_async", true);

            // 创建请求实体
            HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestBody, headers);

            // 发送请求
            String workflowUrl = cozeApiBaseUrl + "/workflow/run";
            ResponseEntity<Map> responseEntity = restTemplate.postForEntity(workflowUrl, requestEntity, Map.class);

            // 处理响应
            if (responseEntity.getStatusCode().is2xxSuccessful()) {
                Map<String, Object> responseBody = responseEntity.getBody();

                // 更新任务状态为处理中
                task.setStatus("processing");
                styleTaskMapper.updateStatus(task.getId(), "processing", null, null, null);

                // 记录工作流运行ID，用于后续查询结果
                if (responseBody != null && responseBody.containsKey("execute_id")) {
                    String workflowRunId = responseBody.get("execute_id").toString();
                    // 保存工作流运行ID到数据库
                    task.setWorkflowRunId(workflowRunId);
                    styleTaskMapper.updateWorkflowRunId(task.getId(), workflowRunId);
                }
            } else {
                // 调用失败，更新任务状态为失败
                String errorMessage = "调用Coze工作流API失败: " + responseEntity.getStatusCode();
                task.setStatus("failed");
                task.setErrorMessage(errorMessage);
                styleTaskMapper.updateStatus(task.getId(), "failed", null, null, errorMessage);
            }
        } catch (Exception e) {
            // 异常处理
            String errorMessage = "调用Coze工作流API异常: " + e.getMessage();
            task.setStatus("failed");
            task.setErrorMessage(errorMessage);
            styleTaskMapper.updateStatus(task.getId(), "failed", null, null, errorMessage);
        }
    }

    /**
     * 查询任务状态
     *
     * @param taskId 任务ID
     * @return 任务状态
     */
    public ApiResponse<Map<String, Object>> getTaskStatus(String taskId) {
        if (taskId == null || taskId.isEmpty()) {
            return ApiResponse.error("任务ID不能为空");
        }

        try {
            // 查询任务
            StyleTask task = styleTaskMapper.findById(taskId);

            if (task == null) {
                return ApiResponse.error("任务不存在");
            }

            // 检查权限（只有任务创建者和管理员可以查询任务状态）
            Long currentUserId = getCurrentUserId();
            if (!task.getUserId().equals(currentUserId) && !isAdmin()) {
                return ApiResponse.error("无权查询此任务");
            }

            // 如果任务状态为处理中，可以调用Coze API查询最新状态
            if ("processing".equals(task.getStatus())) {
                // 调用Coze API查询工作流执行状态
                try {
                    String workflowRunId = task.getWorkflowRunId();
                    if (workflowRunId != null && !workflowRunId.isEmpty()) {
                        // 查询工作流执行状态
                        Map<String, Object> workflowStatus = queryWorkflowStatus(workflowRunId);
                        if (workflowStatus.get("status") == "completed") {
                            // 根据工作流状态更新任务状态
                            updateTaskStatusFromWorkflow(task, workflowStatus);
                        }
                    }
                } catch (Exception e) {
                    // 查询工作流状态失败，但不影响返回任务状态
                    logger.error("查询工作流状态失败: " + e.getMessage(), e);
                }
            }

            // 返回任务状态
            Map<String, Object> result = new HashMap<>();
            result.put("taskId", task.getId());
            result.put("status", task.getStatus());
            result.put("createTime", task.getCreateTime());
            result.put("updateTime", task.getUpdateTime());

            // 如果任务已完成，返回结果URL
            if ("completed".equals(task.getStatus())) {
                result.put("resultUrl", task.getResultUrl());
                result.put("resultInfo", task.getResultInfo());
            }

            // 如果任务失败，返回错误信息
            if ("failed".equals(task.getStatus())) {
                result.put("errorMessage", task.getErrorMessage());
            }

            return ApiResponse.success(result);
        } catch (Exception e) {
            return ApiResponse.error("查询任务状态失败: " + e.getMessage());
        }
    }

    /**
     * 查询工作流执行状态
     *
     * @param workflowRunId 工作流运行ID
     * @return 工作流状态
     */
    private Map<String, Object> queryWorkflowStatus(String workflowRunId) {
        try {
            // 准备请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.set("Authorization", "Bearer " + cozeApiToken);

            // 发送请求
            String url = cozeApiBaseUrl + "/workflows/" + styleTransferWorkflowId + "/run_histories/" + workflowRunId;
            ResponseEntity<Map> responseEntity = restTemplate.exchange(
                url,
                org.springframework.http.HttpMethod.GET,
                new HttpEntity<>(headers),
                Map.class
            );

            // 处理响应
            if (responseEntity.getStatusCode().is2xxSuccessful() && responseEntity.getBody() != null) {
                Map<String, Object> responseBody = responseEntity.getBody();

                // 检查响应码
                if (responseBody.containsKey("code") && Integer.valueOf(0).equals(responseBody.get("code"))) {
                    // 获取data数组中的第一个元素（根据文档，数组只有一个对象）
                    if (responseBody.containsKey("data") && responseBody.get("data") instanceof List) {
                        List<Map<String, Object>> dataList = (List<Map<String, Object>>) responseBody.get("data");
                        if (!dataList.isEmpty()) {
                            Map<String, Object> workflowExecuteHistory = dataList.get(0);

                            // 构建结果Map
                            Map<String, Object> result = new HashMap<>();

                            // 映射状态
                            String executeStatus = (String) workflowExecuteHistory.get("execute_status");
                            if ("Success".equals(executeStatus)) {
                                result.put("status", "completed");
                            } else if ("Fail".equals(executeStatus)) {
                                result.put("status", "failed");
                            } else if ("Running".equals(executeStatus)) {
                                result.put("status", "running");
                            } else {
                                result.put("status", "unknown");
                            }

                            // 处理输出数据
                            if (workflowExecuteHistory.containsKey("output")) {
                                String outputStr = (String) workflowExecuteHistory.get("output");
                                // 尝试解析JSON字符串
                                try {
                                    // 这里需要添加JSON解析库，如Jackson
                                    // 简化处理，将output字段直接放入result
                                    result.put("output", outputStr);
                                } catch (Exception e) {
                                    logger.error("解析工作流输出异常: " + e.getMessage(), e);
                                }
                            }

                            // 添加错误信息（如果有）
                            if (workflowExecuteHistory.containsKey("error_message") &&
                                workflowExecuteHistory.get("error_message") != null &&
                                !((String)workflowExecuteHistory.get("error_message")).isEmpty()) {
                                result.put("error", workflowExecuteHistory.get("error_message"));
                            }

                            return result;
                        }
                    }
                } else {
                    // 响应码不为0，表示调用失败
                    logger.error("查询工作流状态失败: code=" + responseBody.get("code") + ", msg=" + responseBody.get("msg"));
                }
            }

            return null;
        } catch (Exception e) {
            logger.error("查询工作流状态异常: " + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 根据工作流状态更新任务状态
     *
     * @param task 任务
     * @param workflowStatus 工作流状态
     */
    private void updateTaskStatusFromWorkflow(StyleTask task, Map<String, Object> workflowStatus) {
        try {
            // 获取工作流状态
            String status = workflowStatus.get("status") != null ? workflowStatus.get("status").toString() : null;

            // 获取工作流输出
            String outputStr = null;
            if (workflowStatus.get("output") != null) {
                outputStr = workflowStatus.get("output").toString();
            }

            // 根据工作流状态更新任务状态
            if ("completed".equals(status)) {
                // 工作流完成，更新任务状态为已完成
                String resultUrl = null;
                String resultInfo = null;

                // 使用Jackson解析嵌套的JSON
                if (outputStr != null && !outputStr.isEmpty()) {
                    try {
                        // 创建ObjectMapper实例
                        ObjectMapper mapper = new ObjectMapper();

                        // 解析第一层JSON
                        com.fasterxml.jackson.databind.JsonNode rootNode = mapper.readTree(outputStr);



                        // 获取Output字段
                        if (rootNode.has("Output")) {
                            String outputContent = rootNode.get("Output").asText();

                            // 解析Output内部的JSON
                            com.fasterxml.jackson.databind.JsonNode outputNode = mapper.readTree(outputContent);

                            // 获取outputList数组
                            if (outputNode.has("outputList") && outputNode.get("outputList").isArray()) {
                                com.fasterxml.jackson.databind.JsonNode outputList = outputNode.get("outputList");

                                // 获取第一个元素
                                if (outputList.size() > 0) {
                                    com.fasterxml.jackson.databind.JsonNode firstOutput = outputList.get(0);

                                    // 获取data字段
                                    if (firstOutput.has("data") && firstOutput.get("data").has("data")) {
                                        com.fasterxml.jackson.databind.JsonNode dataNode = firstOutput.get("data").get("data");

                                        // 获取image_urls数组
                                        if (dataNode.has("image_urls") && dataNode.get("image_urls").isArray() &&
                                            dataNode.get("image_urls").size() > 0) {
                                            resultUrl = dataNode.get("image_urls").get(0).asText();
                                            
                                            // 下载图片并上传到OSS
                                            try {
                                                // 创建临时文件
                                                File tempFile = null;
                                                try {
                                                    // 使用jpg作为默认扩展名
                                                    String fileExtension = "jpg";
                                                    tempFile = File.createTempFile("task_result_", "." + fileExtension);
                                                    
                                                    // 下载图片到临时文件
                                                    URL url = new URL(resultUrl);
                                                    try (InputStream inputStream = url.openStream()) {
                                                        java.nio.file.Files.copy(
                                                            inputStream,
                                                            tempFile.toPath(),
                                                            java.nio.file.StandardCopyOption.REPLACE_EXISTING
                                                        );
                                                    }
                                                    
                                                    // 上传图片到OSS
                                                    String newImageUrl = ossService.uploadFile(tempFile, "works");
                                                    
                                                    // 更新结果URL为OSS链接
                                                    resultUrl = newImageUrl;
                                                    logger.info("图片已上传到OSS: " + newImageUrl);
                                                } finally {
                                                    // 清理临时文件
                                                    if (tempFile != null && tempFile.exists()) {
                                                        tempFile.delete();
                                                    }
                                                }
                                            } catch (Exception e) {
                                                logger.error("下载并上传图片到OSS失败: " + e.getMessage(), e);
                                                // 如果上传失败，继续使用原始URL
                                            }

                                            // 记录AI生成的描述文本
                                            if (dataNode.has("vlm_result")) {
                                                String description = dataNode.get("vlm_result").asText();
                                                // 这里可以保存描述文本到数据库，如果需要的话'              // 保存整个输出JSON作为resultInfo
                                                resultInfo = description;
                                                logger.info("AI生成描述: " + description);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } catch (Exception e) {
                        logger.error("解析工作流输出JSON异常: " + e.getMessage(), e);
                    }
                }

                // 如果解析失败或结果为空，记录日志
                if (resultUrl == null) {
                    logger.warn("无法从工作流输出中获取结果URL: " + outputStr);
                    // 设置任务状态为失败
                    task.setStatus("failed");
                    task.setErrorMessage("无法获取生成结果");
                    styleTaskMapper.updateStatus(task.getId(), "failed", null, null, "无法获取生成结果");
                    return;
                }

                task.setStatus("completed");
                task.setResultUrl(resultUrl);
                task.setResultInfo(resultInfo);
                styleTaskMapper.updateStatus(task.getId(), "completed", resultUrl, resultInfo, null);
            } else if ("failed".equals(status)) {
                // 工作流失败，更新任务状态为失败
                String errorMessage = null;
                if (workflowStatus.containsKey("error")) {
                    errorMessage = workflowStatus.get("error").toString();
                } else {
                    errorMessage = "工作流执行失败";
                }

                task.setStatus("failed");
                task.setErrorMessage(errorMessage);
                styleTaskMapper.updateStatus(task.getId(), "failed", null, null, errorMessage);
            }
            // 其他状态（如running）保持任务状态为processing
        } catch (Exception e) {
            logger.error("更新任务状态异常: " + e.getMessage(), e);
        }
    }

    /**
     * 查询用户的任务列表
     *
     * @return 任务列表
     */
    public ApiResponse<List<StyleTask>> getUserTasks() {
        try {
            // 获取当前用户ID
            Long userId = getCurrentUserId();

            // 查询用户的任务列表
            List<StyleTask> tasks = styleTaskMapper.findByUserId(userId);

            return ApiResponse.success(tasks);
        } catch (Exception e) {
            return ApiResponse.error("查询任务列表失败: " + e.getMessage());
        }
    }

    /**
     * 更新任务状态
     *
     * @param taskId 任务ID
     * @param status 任务状态
     * @param resultUrl 结果URL
     * @param resultInfo 结果附加信息
     * @param errorMessage 错误信息
     * @return 是否成功
     */
    public boolean updateTaskStatus(String taskId, String status, String resultUrl, String resultInfo, String errorMessage) {
        try {
            int rows = styleTaskMapper.updateStatus(taskId, status, resultUrl, resultInfo, errorMessage);
            return rows > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 接收Coze工作流回调
     *
     * @param taskId 任务ID
     * @param status 任务状态
     * @param resultUrl 结果URL
     * @param resultInfo 结果附加信息
     * @param errorMessage 错误信息
     * @return API响应
     */
    public ApiResponse<Void> handleWorkflowCallback(String taskId, String status, String resultUrl, String resultInfo, String errorMessage) {
        try {
            // 更新任务状态
            boolean updated = updateTaskStatus(taskId, status, resultUrl, resultInfo, errorMessage);

            if (updated) {
                return ApiResponse.success(null);
            } else {
                return ApiResponse.error("更新任务状态失败");
            }
        } catch (Exception e) {
            return ApiResponse.error("处理工作流回调失败: " + e.getMessage());
        }
    }

    /**
     * 生成任务ID
     *
     * @return 任务ID
     */
    private String generateTaskId() {
        return "task_" + System.currentTimeMillis() + "_" + (int) (Math.random() * 1000);
    }

    /**
     * 将风格ID列表转换为字符串
     *
     * @param styleIds 风格ID列表
     * @return 逗号分隔的风格ID字符串
     */
    private String convertStyleIdsToString(List<Long> styleIds) {
        if (styleIds == null || styleIds.isEmpty()) {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        for (Long styleId : styleIds) {
            if (sb.length() > 0) {
                sb.append(",");
            }
            sb.append(styleId);
        }

        return sb.toString();
    }

    /**
     * 获取当前用户ID
     *
     * @return 用户ID
     */
    private Long getCurrentUserId() {
        try {
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            Object principal = authentication.getPrincipal();

            // 从自定义UserDetails中获取用户ID
            if (principal instanceof com.styletransfer.security.CustomUserDetailsService.CustomUserDetails) {
                return ((com.styletransfer.security.CustomUserDetailsService.CustomUserDetails) principal).getUserId();
            }

            // 尝试从请求属性中获取用户ID
            javax.servlet.http.HttpServletRequest request =
                ((org.springframework.web.context.request.ServletRequestAttributes)
                org.springframework.web.context.request.RequestContextHolder.getRequestAttributes()).getRequest();
            Object userId = request.getAttribute("userId");
            if (userId != null) {
                return (Long) userId;
            }

            throw new RuntimeException("无法获取用户ID");
        } catch (Exception e) {
            throw new RuntimeException("获取用户ID失败: " + e.getMessage());
        }
    }

    /**
     * 判断当前用户是否为管理员
     *
     * @return 是否为管理员
     */
    private boolean isAdmin() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return false;
        }

        return authentication.getAuthorities().stream()
                .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
    }

    /**
     * 获取风格名称
     *
     * @param styleId 风格ID
     * @return 风格名称
     */
    private String getStyleNameById(String styleId) {
        try {
            // 将字符串ID转换为Long类型
            Long id = Long.parseLong(styleId);

            // 调用StyleService获取风格对象
            ApiResponse<Style> response = styleService.findById(id);

            // 如果成功获取到风格对象，返回其名称
            if (response != null && response.getCode() == 200 && response.getData() != null) {
                return response.getData().getName();
            }

            // 如果获取失败，返回默认风格名称
            return "日漫风格";
        } catch (Exception e) {
            // 异常处理，返回默认风格名称
            return "日漫风格";
        }
    }

    /**
     * 查询用户的任务列表（带分页和筛选）
     *
     * @param page 页码
     * @param size 每页数量
     * @param status 任务状态
     * @return 任务列表
     */
    public ApiResponse<Map<String, Object>> getUserTasksWithPagination(Integer page, Integer size, String status) {
        try {
            // 获取当前用户ID
            Long userId = getCurrentUserId();

            // 参数校验
            if (page < 1) {
                page = 1;
            }

            if (size < 1 || size > 100) {
                size = 10;
            }

            // 查询用户的任务列表
            List<StyleTask> tasks = styleTaskMapper.findByUserId(userId);

            for (StyleTask task : tasks) {
                String styleIds = task.getStyleIds();
                String[] styleIdArray = styleIds.split(",");
                ArrayList<Style> styles = new ArrayList<>();
                for (String styleId : styleIdArray) {
                    Style style = styleMapper.findById(Long.valueOf(styleId));
                    styles.add(style);
                }
                task.setStyles(styles);
            }


            // 根据状态筛选
            if (status != null && !status.isEmpty()) {
                tasks = tasks.stream()
                        .filter(task -> status.equals(task.getStatus()))
                        .collect(Collectors.toList());
            }

            // 计算总数
            int total = tasks.size();

            // 分页
            int startIndex = (page - 1) * size;
            int endIndex = Math.min(startIndex + size, total);

            List<StyleTask> pagedTasks;
            if (startIndex < total) {
                pagedTasks = tasks.subList(startIndex, endIndex);
            } else {
                pagedTasks = new ArrayList<>();
            }

            // 构建返回结果
            Map<String, Object> result = new HashMap<>();
            result.put("total", total);
            result.put("page", page);
            result.put("size", size);
            result.put("list", pagedTasks);

            return ApiResponse.success(result);
        } catch (Exception e) {
            return ApiResponse.error("查询任务列表失败: " + e.getMessage());
        }
    }

    /**
     * 取消任务
     *
     * @param taskId 任务ID
     * @return 操作结果
     */
    public ApiResponse<Void> cancelTask(String taskId) {
        try {
            // 获取当前用户ID
            Long userId = getCurrentUserId();

            // 查询任务
            StyleTask task = styleTaskMapper.findById(taskId);

            // 检查任务是否存在
            if (task == null) {
                return ApiResponse.error("任务不存在");
            }

            // 检查任务是否属于当前用户
            if (!task.getUserId().equals(userId) && !isAdmin()) {
                return ApiResponse.error("无权操作此任务");
            }

            // 检查任务状态是否可取消
            if (!"waiting".equals(task.getStatus()) && !"processing".equals(task.getStatus())) {
                return ApiResponse.error("只能取消等待中或处理中的任务");
            }

            // 更新任务状态为已取消
            boolean updated = updateTaskStatus(taskId, "canceled", null, null, "用户取消任务");

            if (updated) {
                // 如果任务正在处理中，尝试调用Coze API取消工作流
                if ("processing".equals(task.getStatus()) && task.getWorkflowRunId() != null) {
                    try {
                        // 调用Coze API取消工作流
                        cancelWorkflow(task.getWorkflowRunId());
                    } catch (Exception e) {
                        // 取消工作流失败，但不影响任务取消
                        logger.error("取消工作流失败: " + e.getMessage(), e);
                    }
                }

                return ApiResponse.success(null);
            } else {
                return ApiResponse.error("取消任务失败");
            }
        } catch (Exception e) {
            return ApiResponse.error("取消任务失败: " + e.getMessage());
        }
    }

    /**
     * 取消工作流
     *
     * @param workflowRunId 工作流运行ID
     */
    private void cancelWorkflow(String workflowRunId) {
        // 准备请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("Authorization", "Bearer " + cozeApiToken);

        // 发送请求
        String url = cozeApiBaseUrl + "/workflows/" + styleTransferWorkflowId + "/run_histories/" + workflowRunId + "/cancel";
        ResponseEntity<Map> responseEntity = restTemplate.exchange(
            url,
            org.springframework.http.HttpMethod.POST,
            new HttpEntity<>(headers),
            Map.class
        );

        // 处理响应
        if (!responseEntity.getStatusCode().is2xxSuccessful()) {
            throw new RuntimeException("取消工作流失败: " + responseEntity.getStatusCode());
        }
    }

    /**
     * 删除任务
     *
     * @param taskId 任务ID
     * @return 操作结果
     */
    public ApiResponse<Void> deleteTask(String taskId) {
        try {
            // 获取当前用户ID
            Long userId = getCurrentUserId();

            // 查询任务
            StyleTask task = styleTaskMapper.findById(taskId);

            // 检查任务是否存在
            if (task == null) {
                return ApiResponse.error("任务不存在");
            }

            // 检查任务是否属于当前用户
            if (!task.getUserId().equals(userId) && !isAdmin()) {
                return ApiResponse.error("无权操作此任务");
            }

            // 删除任务
            int rows = styleTaskMapper.deleteById(taskId);

            if (rows > 0) {
                return ApiResponse.success(null);
            } else {
                return ApiResponse.error("删除任务失败");
            }
        } catch (Exception e) {
            return ApiResponse.error("删除任务失败: " + e.getMessage());
        }
    }

    /**
     * 将任务保存为作品
     *
     * @param taskId 任务ID
     * @param title 作品标题
     * @param description 作品描述
     * @param isPublic 是否公开
     * @return 操作结果
     */
    public ApiResponse<Void> saveTaskAsWork(String taskId, String title, String description, Boolean isPublic) {
        try {
            // 获取当前用户ID
            Long userId = getCurrentUserId();

            // 查询任务
            StyleTask task = styleTaskMapper.findById(taskId);

            // 检查任务是否存在
            if (task == null) {
                return ApiResponse.error("任务不存在");
            }

            // 检查任务是否属于当前用户
            if (!task.getUserId().equals(userId) && !isAdmin()) {
                return ApiResponse.error("无权操作此任务");
            }

            // 检查任务是否已完成
            if (!"completed".equals(task.getStatus())) {
                return ApiResponse.error("只能将已完成的任务保存为作品");
            }

            // 检查任务是否有结果URL
            if (task.getResultUrl() == null || task.getResultUrl().isEmpty()) {
                return ApiResponse.error("任务没有生成结果");
            }

            // 调用WorkService保存作品
            // 注意：这里需要注入WorkService
            return workService.createWorkFromTask(task, title, description, isPublic != null ? isPublic : false);
        } catch (Exception e) {
            return ApiResponse.error("保存作品失败: " + e.getMessage());
        }
    }
}
